﻿#define  _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
#include<stack>
#include<list>
using namespace std;

//template<class T, size_t N = 12>//也支持缺省参数
//class Stack
//{
//private:
//	T _a[N];
//	int _top;
//};

////C++20开始支持
//template<double N>
//class AA
//{ };
//
////指针也支持
//template<double N, int* ptr>
//class AA
//{ };
//
//int main()
//{
//	Stack<int> st1; // 12
//	Stack<int, 1000> st2; // 1000
//}

#include<array>

//void func(int* a)
//{
//	//不能使用范围for
//	for (auto e : a)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//}
//
//void func(const array<int, 10>& a)
//{
//	//能使用范围for
//	for (auto e : a)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//}
//
//int main()
//{
//	//内置类型做参数，默认不会初始化
//	array<int, 10> a1;
//	a1.fill(0);
//	a1[3] = 3;
//	a1[9] = 9;
//	for (auto e : a1)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//	cout << sizeof(a1) << endl;//编译时开辟，效率更高
//
//	int a2[10];
//	a2[3] = 3;
//	a2[9] = 9;
//	for (auto e : a2)
//	{
//		cout << e << " ";
//	}
//	cout << endl;
//
//	list<array<int, 10>> lt;
//	func(a1);
//	//func(a2);
//
//	// 数组越界只能检查写，并且是抽查，
//	//a2[10] = 1; // 可以查出来
//	//a2[15] = 1;   // 不能查出来
//	//cout << a2[10] << endl;  // 越界读更不会检查
//
//	//// 上面对array都不是问题，都可以检查出来，因为他是运算符重载调用，内存严格检查
//	//a1[15] = 1;
//	//cout << a1[10] << endl;
//	return 0;
//}
class Date
{
public:
	Date(int year = 1900, int month = 1, int day = 1)
		: _year(year)
		, _month(month)
		, _day(day)
	{
	}

	bool operator<(const Date& d)const
	{
		return (_year < d._year) ||
			(_year == d._year && _month < d._month) ||
			(_year == d._year && _month == d._month && _day < d._day);
	}

	bool operator>(const Date& d)const
	{
		return (_year > d._year) ||
			(_year == d._year && _month > d._month) ||
			(_year == d._year && _month == d._month && _day > d._day);
	}

	friend ostream& operator<<(ostream& _cout, const Date& d);
private:
	int _year;
	int _month;
	int _day;
};

ostream& operator<<(ostream& _cout, const Date& d)
{
	_cout << d._year << "-" << d._month << "-" << d._day;
	return _cout;
}

//template<class T>
//bool Less(const T& left, const T& right)
//{
//	return left < right;
//}
//
////对于上述函数模板实现一个特化版本
//template<>
//bool Less<Date*>(Date* const& left, Date* const& right)//const修饰引用本身，放在Date*右边
//{
//	return *left < *right;
//}
//
////普通函数与函数模板可以同时存在
//bool Less(Date* left, Date* right)
//{
//	return *left < *right;
//}
//
//int main()
//{
//	cout << Less(1, 2) << endl; // 可以比较，结果正确
//
//	Date* p1 = new Date(2025, 10, 3);
//	Date* p2 = new Date(2025, 10, 6);
//	cout << Less(p1, p2) << endl; //可以比较，结果错误，特化之后结果正确
//	return 0;
//}

//template<class T1, class T2>
//class Data
//{
//public:
//	Data() { cout << "Data<T1, T2>" << endl; }
//private:
//	T1 _d1;
//	T2 _d2;
//};
//
////类模板特化，对内部成员没有要求
////全特化
//template<>
//class Data<int, double>
//{
//public:
//	Data() { cout << "Data<T1, T2>特化" << endl; }
//	void func() { }
//};
//
////偏特化
//template<class T1>
//class Data<T1, char>
//{
//public:
//	Data() { cout << "Data<T1, char>半特化" << endl; }
//};
//
////两个参数偏特化为指针类型 
//template <typename T1, typename T2>
//class Data <T1*, T2*>
//{
//public:
//	Data() { cout << "Data<T1*, T2*>" << endl; }
//	void func()
//	{
//		cout << typeid(T1).name() << endl;
//		cout << typeid(T2).name() << endl;
//	}
//};
//
////两个参数偏特化为引用类型
//template <typename T1, typename T2>
//class Data <T1&, T2&>
//{
//public:
//	Data()
//	{
//		cout << "Data<T1&, T2&>" << endl;
//	}
//};
//
//int main()
//{
//	Data<int, int> d1;
//	//d1.func(); 不能调用
//	Data<int, double>d2;
//	d2.func();
//
//	Data<int, char>d3;
//	Data<char*, double*>d4;
//	d4.func();
//
//	Data<char&, double&>d5;
//
//	return 0;
//}

//namespace xxx
//{
//	// 特化版本
//	template <>
//	struct Less<Date*>
//	{
//		//bool operator() (const Date* const& x, const Date* const& y) const
//		bool operator() (const Date* x, const Date* y) const
//		{ 
//			return *x < *y;
//		}
//	};
//	
//	// 偏特化，所有指针都按照指向的内容去比较
//	/*template <class T>
//	struct Less<T*>
//	{
//		bool operator() (const T* x, const T* y) const
//		{
//			return *x < *y;
//		}
//	};*/
//
//	template <>
//	struct Greater<Date*>
//	{
//		bool operator() (const Date* const& x, const Date* const& y) const 
//		{ 
//			return *x > *y;
//		}
//	};
//}
//
//int main()
//{
//	xxx::priority_queue<Date*> pq;
//	//xxx::priority_queue<Date*, vector<Date*>, xxx::Greater<Date*>> pq;
//	pq.push(new Date(2025, 1, 1));
//	pq.push(new Date(2025, 1, 3));
//	pq.push(new Date(2025, 1, 2));
//	while (!pq.empty())
//	{
//		cout << *pq.top() << " ";
//		pq.pop();
//	}
//	cout << endl;
//
//	return 0;
//}

